import java.util.Arrays;

public class Test2 {

    //实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值.
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static void main1(String[] args) {
        //创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
        int[] array = new int[100];
        for (int i = 0; i < 100; i++) {
            array[i] = i + 1;
        }

        printArray(array);
    }

    //实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
    public static void transForm(int[] array) {
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] * 2;
        }
    }

    public static void main2(String[] args) {
        int[] array = {1,2,3};
        transForm(array);
        System.out.println(Arrays.toString(array));
    }

    //调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。
    public static void func1(int[] array) {
       int left = 0;
       int right = array.length - 1;
       while (left < right) {
           while (left < right && array[left] % 2 != 0) {
               left++;
           }
           while (left < right && array[right] % 2 == 0) {
               right--;
           }
           int tmp = array[left];
           array[left] = array[right];
           array[right] = tmp;
       }
    }

    public static void main3(String[] args) {
        int[] array = {1,2,3,4,5,6};
        func1(array);
        System.out.println(Arrays.toString(array));
    }


    //二分查找
    public static int func2(int[] array, int n) {
        int left = 0;
        int right = array.length;
        while (left <= right) {
            int mid = (right - left) / 2 + left;
            if(array[mid] > n) {
                right = mid - 1;
            } else if (array[mid] < n) {
                left = mid + 1;
            } else {
                return mid;
            }
        }
        return -1;
    }

    public static void main4(String[] args) {
        int[] array = {1,2,3,4,5,6};
        System.out.println(func2(array,1));
        System.out.println(func2(array,2));
        System.out.println(func2(array,3));
        System.out.println(func2(array,4));
        System.out.println(func2(array,5));
        System.out.println(func2(array,6));
    }

    //给定一个整型数组, 实现冒泡排序(升序排序
    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int tmp = 0;
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    tmp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = tmp;
                }
            }
            //tmp为0 说明上一轮没有交换，数组已经有序，可以结束
            if (tmp == 0) {
                break;
            }
        }
    }

    public static void main5(String[] args) {
        int[] array = {9,8,1,6,7,2,3,4,5};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

    //给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
    //你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
    //你可以按任意顺序返回答案。
    //示例 1：
    //输入：nums = [2,7,11,15], target = 9
    //输出：[0,1]
    //解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

    public static int[] func3(int[] array, int target) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] + array[j] == target) {
                    int[] ret = {i ,j};
                    return ret;
                }
            }
        }
        return null;
    }

    public static void main6(String[] args) {
        int[] nums = {2,7,11,15};
        System.out.println(Arrays.toString(func3(nums, 22)));

    }

    //给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
    public static int func4(int[] array) {
        int ret = 0;
        for (int i = 0; i < array.length; i++) {
            ret ^= array[i];
        }
        return ret;
    }

    public static void main7(String[] args) {
        int[] array1 = {4,1,2,1,2};
        int[] array2 = {2,2,1};
        System.out.println(func4(array1));
        System.out.println(func4(array2));
    }

    //给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
    //你可以假设数组是非空的，并且给定的数组总是存在多数元素。
    public static int func5(int[] array) {
        int ret = array[0];
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            if(count == 0) {
                ret = array[i];
            }
            if (ret == array[i]) {
                count++;
            } else {
                count--;
            }
        }
        return ret;
    }

    public static void main8(String[] args) {
        int[] array1 = {3,2,3};
        int[] array2 = {2,2,1,1,1,2,2};
        System.out.println(func5(array1));
        System.out.println(func5(array2));
    }

    //给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。
    public static boolean func6(int[] array) {
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] % 2 != 0) {
                count++;
            } else {
                count = 0;
            }
            if (count == 3) {
                break;
            }
        }
        if (count == 3) {
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) {
        int[] arr1 = {2,6,4,1};
        int[] arr2 = {1,2,34,3,4,5,7,23,12};
        System.out.println(func6(arr1));
        System.out.println(func6(arr2));
    }
}
